
import numpy as np
import time 
import cv2
import os 
import glob
import matplotlib.pyplot as plt
from moviepy.editor import VideoFileClip


# weights contain the resulted weights from the pretrained model
# CFG contained neural network architecture
weights_path = os.path.join("yolo","yolov3.weights")
Cfg_Path = os.path.join("yolo","yolov3.cfg")


#Save The Neural Networj in a variable
net =cv2.dnn.readNetFromDarknet(Cfg_Path,weights_path)


# Get all The Layer names from yolov3 architecture
names = net.getLayerNames()


# get connectedOutLayersNames returns the only the 3 output layers in yolov3 from our saved neural net
# which are yolo_82,yolo_94,yolo_106 in a tuple 
# Then we convert tuple into a list
layers_names = net.getUnconnectedOutLayersNames()
list(layers_names)

['yolo_82', 'yolo_94', 'yolo_106']


#Get Binary Large Object from img (BLOB) 
#blobFromImage(Img,scale Factor,size,crop,swapRB =true since our image is BGR)
def blobimg(img):
    
    blob = cv2.dnn.blobFromImage(img,1/255.0,(416,416),crop = False, swapRB = True)
    #Input Our Blob into the Neural Net
    net.setInput(blob)
    #start Timer
    start_t=time.time()
    # Forward pass the layers to compute net output returns a np array that will be used to plot box
    layers_out=net.forward(layers_names)
    #show How long did it take
    print("Time To Forward Pass Layers is: {}".format(time.time()-start_t))
    return layers_out


# Function that detects class according to confidence value
# the max score from the output layer is the class we're detecting
def detection_f(layers_out,Height , Width):
    boxes=[]
    confidences=[]
    classIDs=[]
    # Output Counter that contains yolo_82,yolo_94,yolo_106 tuple
    for output in layers_out:
        # Detection counter contain counter that passes through the output_layers iteratively 
        for detection in output:
            # Get the class with the highst score
            scores = detection[5:]
            classID = np.argmax(scores)
            confidence= scores[classID]
            
            # only draw box if confidence is greater than 85%

            if confidence>0.85:
                box = detection[:4] *np.array([Width,Height,Width,Height])
                bx,by,bw,bh=box.astype("int")
                
                # derive the top and left corner
                x=int(bx-(bw/2))
                y=int(by-(bh/2))

                boxes.append([x,y,int(bw),int(bh)])
                confidences.append(float(confidence))
                classIDs.append(classID)
    # perform non maximum suppression            
    indxs=cv2.dnn.NMSBoxes(boxes,confidences,0.8,0.8)
    return indxs, boxes,classIDs,confidences


# Import Labels from yolo folder
labels_path = os.path.join("yolo","coco.names")
#Clear labels from any spaces and any newlines
labels=open(labels_path).read().strip().split("\n")


# Function that draw box around detected object
def flatten(img,indxs,boxes,classIDs,confidences):
    if len(indxs) > 0:
        for i in indxs.flatten():
            # Get box dimensions and center
            (x,y)=[boxes[i][0],boxes[i][1]]
            (w,h)=[boxes[i][2],boxes[i][3]]

            #Draw Rectangle
            cv2.rectangle(img,(x,y),(x+w,y+h),(255,120,0),2)
            #Put Text above detcted object that contains label and confidence
            cv2.putText(img,"{}: {:0.4f}".format(labels[classIDs[i]],confidences[i]),(x,y-5),cv2.FONT_HERSHEY_SIMPLEX,0.5,(255,120,0),2)


def process_image(img):
    
 #   img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
    Height , Width =img.shape[:2]
    layers_out=blobimg(img)
    indxs, boxes,classIDs,confidences=detection_f(layers_out,Height , Width)
    flatten(img,indxs,boxes,classIDs,confidences)
#    img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
    return img


# Import Image
img_path = os.path.join("yolo","lane.jpeg")

img = cv2.imread(img_path)


# We will process with BGR Image since we added the parameter swapRB = true in the blob image
plt.imshow(img)
plt.title("BGR Image")

Text(0.5, 1.0, 'BGR Image')


#Write Image
cv2.imwrite("lane.jpeg",process_image(img))

Time To Forward Pass Layers is: 0.5928423404693604

True


inputvideo= 'test.mp4'
outputvideo= 'object1.mp4'

myclip = VideoFileClip(inputvideo)
clip = myclip.fl_image(process_image)

%time clip.write_videofile(outputvideo, audio=False)

t:   0%|          | 0/9184 [00:00<?, ?it/s, now=None]

Time To Forward Pass Layers is: 0.29720473289489746
Moviepy - Building video object1.mp4.
Moviepy - Writing video object1.mp4

t:   0%|          | 2/9184 [00:00<28:14,  5.42it/s, now=None]

Time To Forward Pass Layers is: 0.32413268089294434

t:   0%|          | 3/9184 [00:00<39:02,  3.92it/s, now=None]

Time To Forward Pass Layers is: 0.307178258895874

t:   0%|          | 4/9184 [00:01<44:51,  3.41it/s, now=None]

Time To Forward Pass Layers is: 0.3071768283843994

t:   0%|          | 5/9184 [00:01<47:55,  3.19it/s, now=None]

Time To Forward Pass Layers is: 0.3041861057281494

Object Detection - Phase 2 Computer Vision¶

Youssef Mohamed Mansi 18P5848¶

Seif Ahmed Elsayed Elewa 18P5662¶

Seif Muhammed Yakout 18P2158¶

Importing Libraries¶

Load Yolo Weights/ CFG¶

Load Neural Net¶

Show Layers Names¶

Layers Out Vector¶

Get Labels for detection¶

Draw Box around Detected Object¶

Process Image¶

Test On Image¶

Test On video¶